package com.zenithmind.user.controller;

import com.zenithmind.common.annotation.Log;
import com.zenithmind.common.constant.OperationTypeEnum;
import com.zenithmind.common.result.ResultCode;
import com.zenithmind.user.pojo.domain.Role;
import com.zenithmind.user.pojo.domain.RolePermission;
import com.zenithmind.user.pojo.query.RoleQuery;
import com.zenithmind.user.pojo.vo.RoleVO;
import com.zenithmind.user.service.RoleService;
import org.springframework.web.bind.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import com.zenithmind.common.result.PageResult;
import com.zenithmind.common.result.Result;
import lombok.extern.slf4j.Slf4j;

import java.util.List;

@Slf4j
@RestController
@RequestMapping("/api/zenithMind/role")
@Tag(name = "角色管理")
public class RoleController {
    @Autowired
    private RoleService roleService;
    
    /**
     * 添加角色接口
     * 该接口用于接收通过POST方法发送的角色信息，并将其保存到系统中
     * 主要用于角色的创建或新增操作
     *
     * @param role 角色对象，包含角色的相关信息，如角色名称、权限等
     *             通过请求体（@RequestBody）接收，意味着角色信息以JSON格式在请求体中发送
     * @return 返回一个Result对象，包含保存后的角色信息
     *         使用Result.success封装表示操作成功，除了成功信息，还可以根据需要封装其他数据
     */
    @Log(description = "添加角色", operationType = OperationTypeEnum.ADD)
    @Operation(summary = "添加角色")
    @PostMapping("/addRole")
    public Result<Role> addRole(@RequestBody Role role) {
        roleService.save(role);
        return Result.success(role);
    }
    
    /**
     * 修改角色信息
     *
     * 该方法通过PUT请求接收一个Role对象作为请求体，更新数据库中对应的角色信息
     * 主要用于角色信息的修改操作，如更改角色名称、权限等
     *
     * @param role 待更新的角色对象，包含需要修改的角色信息
     * @return 返回更新后的角色对象，表示操作成功
     */
    @Log(description = "修改角色信息", operationType = OperationTypeEnum.UPDATE)
    @Operation(summary = "修改角色")
    @PutMapping("/updateRole")
    public Result<Role> update(@RequestBody Role role) {
        roleService.updateById(role);
        return Result.success(role);
    }
    
    /**
     * 删除指定的角色
     *
     * @param id 角色的唯一标识符
     * @return 返回操作结果的字符串信息
     */
    @Log(description = "删除角色", operationType = OperationTypeEnum.DELETE)
    @Operation(summary = "删除角色")
    @DeleteMapping("/deleteRole/{id}")
    public Result<String> delete(@PathVariable String id) {
        roleService.removeById(id);
        return Result.success();
    }
    
    /**
     * 批量删除角色的接口方法
     * 该方法通过接收一个角色ID列表来实现批量删除角色的功能
     * 主要用于系统管理、角色维护等场景，以简化管理员的操作
     *
     * @param ids 角色ID列表，包含需要删除的角色的唯一标识符
     * @return 返回一个Result对象，表示删除操作的结果
     *         如果删除成功，Result对象将表示成功状态
     */
    @Log(description = "批量删除角色", operationType = OperationTypeEnum.DELETE)
    @Operation(summary = "批量删除角色")
    @DeleteMapping("/batchDeleteRoles")
    public Result<String> deleteBatch(@RequestBody List<String> ids) {
        roleService.removeBatchByIds(ids);
        return Result.success();
    }
    
    /**
     * 根据ID查询角色
     *
     * @param id 角色ID，用于唯一标识一个角色
     * @return 返回包含角色详细信息的Result对象
     */
    @Log(description = "根据ID查询角色", operationType = OperationTypeEnum.QUERY)
    @Operation(summary = "根据ID查询角色")
    @GetMapping("/getRoleById/{id}")
    public Result<RoleVO> getById(@PathVariable String id) {
        return Result.success(roleService.getRoleById(id));
    }

    /**
     * 分页查询角色
     *
     * @param roleQuery 角色查询对象，包含分页信息和查询条件
     * @return 返回包含角色分页查询结果的Result对象
     */
    @Log(description = "分页查询角色", operationType = OperationTypeEnum.QUERY)
    @Operation(summary = "分页查询角色")
    @GetMapping({"/pageRole"})
    public Result<PageResult<RoleVO>> page(RoleQuery roleQuery) {
        return Result.success(roleService.page(roleQuery));
    }

    /**
     * 查询所有角色
     *
     * @return 返回包含所有角色信息的Result对象
     */
    @Log(description = "查询所有角色", operationType = OperationTypeEnum.QUERY)
    @Operation(summary = "查询所有角色")
    @GetMapping("/listRoles")
    public Result<List<RoleVO>> list() {
        return Result.success(roleService.listRoles());
    }

    /**
     * 分配权限给角色
     *
     * @param rolePermission 角色和权限的关联信息，包括角色ID和权限ID列表
     * @return 返回表示操作成功的Result对象
     */
    @Log(description = "分配权限给角色", operationType = OperationTypeEnum.UPDATE)
    @Operation(summary = "分配权限")
    @PostMapping("/assignPermissionToRole")
    public Result<String> assignPermission(@RequestBody RolePermission rolePermission) {
        roleService.assignPermission(rolePermission);
        return Result.success();
    }
    
    /**
     * 批量分配权限给角色
     * 
     * @param roleId 角色ID
     * @param permissionIds 权限ID列表
     * @return 返回表示操作成功的Result对象
     */
    @Log(description = "批量分配权限给角色", operationType = OperationTypeEnum.UPDATE)
    @Operation(summary = "批量分配权限")
    @PostMapping("/assignPermissions")
    public Result<String> assignPermissions(@RequestParam String roleId, @RequestBody List<String> permissionIds) {
        roleService.assignBatchPermissions(roleId, permissionIds);
        return Result.success("权限分配成功");
    }
    
    /**
     * 获取角色的权限列表
     * 
     * @param roleId 角色ID
     * @return 返回角色拥有的权限ID列表
     */
    @Log(description = "获取角色权限", operationType = OperationTypeEnum.QUERY)
    @Operation(summary = "获取角色权限")
    @GetMapping("/permissions/{roleId}")
    public Result<List<String>> getRolePermissions(@PathVariable String roleId) {
        return Result.success(roleService.getRolePermissionIds(roleId));
    }
    
    /**
     * 更新角色状态
     *
     * @param role 角色对象，包含角色ID和状态信息
     * @return 返回表示操作成功的Result对象
     */
    @Log(description = "更新角色状态", operationType = OperationTypeEnum.UPDATE)
    @Operation(summary = "更新角色状态")
    @PostMapping("/updateStatus")
    public Result<String> updateStatus(@RequestBody Role role) {
        if (role == null || role.getId() == null) {
            return Result.fail(ResultCode.PARAM_ERROR, "角色ID不能为空");
        }
        roleService.updateById(role);
        return Result.success("状态更新成功");
    }
}
